// 增
const path = require("path");
var express = require("express");
var dayjs = require("dayjs");
var router = express.Router();
const db = require("../disposition/db");
var fs = require("fs");
var formidable = require("formidable");
// 钥匙
var key = require("../disposition/key");
// 新增角色——————————————————————————————————————————————————————————————————————————————————————
router.post("/role", (req, res) => {
  console.log("新增角色");
  // 查询审核数据库最大的id值
  const sql = "SELECT max(id) FROM character_guide";
  db.query(sql, (err, result) => {
    if (err) {
      return;
    }
    // 获取最大id的数组
    let ItemID = null;
    // 获取最新的id号
    let ID = null;
    // 循环查询后返回的最大id值
    result.some((item) => {
      // 给其数组赋值
      ItemID = Object.values(item);
    });
    // 判断是否为空是的话最新id为1，反之用最大id+1
    ItemID[0] === null ? (ID = 1) : (ID = ItemID[0] + 1);
    // 后端需要赋值的key字段，创建人、创建人id，创建时间，状态，id,审批状态，修改库
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "state",
      "id",
      "Agree",
      "storehouse",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = `${new Date().getFullYear()}-${
      new Date().getMonth() + 1 < 10
        ? `0${new Date().getMonth() + 1}`
        : new Date().getMonth() + 1
    }-${
      new Date().getDate() < 10
        ? `0${new Date().getDate()}`
        : new Date().getDate()
    }`;
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}',0,${ID},0,0`;
    // 将前后端的合并
    Values = Values + Valuess;

    // 请求数据库
    const sql2 = `INSERT INTO character_guide(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          msg: "新增成功！",
          success: true,
        });
      }
    });
  });
});
// 新增角色图片上传——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/StandingPainting", (req, res) => {
  console.log("新增角色图片上传");
  // 获取请求头传回来的更新列与更新id
  // state等于0初始立绘、1是6契立绘、2是扇子立绘
  let state = req.get("state");
  let id = req.get("id");
  // 判断传回来的更新状态和更新审核单号是否有空
  if (state === "" || state === undefined || id === "" || id === undefined) {
    res.send({
      msg: "上传失败！",
      success: false,
    });
  } else {
    // 查询角色审核库里是否有此数据
    const sql = `SELECT * from character_guide WHERE id=${id}`;
    db.query(sql, (err, result) => {
      if (err) {
        return;
      }
      if (result.length === 0) {
        // 判断是否找不到或则已经被审批过了
        res.send({
          msg: "未找到相应的审核数据！",
          success: false,
        });
      } else if (result[0].Agree !== 0) {
        res.send({
          msg: "当前审核数据已被审批！",
          success: false,
        });
      } else {
        // 修改文件名的绝对路径
        let url = null;
        // 保存文件的路径
        let URL = null;
        // 判断到底是什么图片提交赋值对应的保存修改的路径
        if (state === "0") {
          url = path.join(`${key.URL}persona-fales/`);
          URL = "/../public/images/persona-fales";
        } else if (state === "1") {
          url = path.join(`${key.URL}persona-true/`);
          URL = "/../public/images/persona-true";
        } else if (state === "2") {
          url = path.join(`${key.URL}fan/`);
          URL = "/../public/images/fan";
        }
        // 进行保存图片
        let form = formidable({
          multiples: true,
          uploadDir: __dirname + URL, //指定上传到当前项目的那个文件下
          keepExtensions: true, //是否保留后缀名
        });
        //上传完成后的操作
        form.parse(req, (err, fields, files) => {
          if (err) {
            next(err);
            return;
          }
          // 修改文件名，原文件绝对路径，修改后文件绝对路径
          fs.rename(
            url + files.file.newFilename,
            url + id + `.png`,
            (err) => {}
          );
          //响应返回上传文件存放的路径
          // res.json({ url: "/images/" + files.file.newFilename });
          // 修改子段数据库函数
          let sql2 = null;
          let URL2 = null;
          //判断修改那个字段
          if (state === "0") {
            sql2 = `UPDATE character_guide SET Standing_painting_fales='/images/persona-fales/${id}.png' WHERE id=${id}`;
            URL2 = `/images/persona-fales/${id}.png`;
          } else if (state === "1") {
            sql2 = `UPDATE character_guide SET Standing_painting_true='/images/persona-true/${id}.png' WHERE id=${id}`;
            URL2 = `/images/persona-true/${id}.png`;
          } else if (state === "2") {
            sql2 = `UPDATE character_guide SET fan='/images/fan/${id}.png' WHERE id=${id}`;
            URL2 = `/images/fan/${id}.png`;
          }
          //修改数据库相应数据的图片路径
          db.query(sql2, function (err, rows) {
            if (err) {
              res.send({
                data: "保存数据库失败",
                success: false,
              });
            } else {
              res.send({
                data: URL2,
                success: true,
              });
            }
          });
        });
      }
    });
  }
});
// 新增灯幻镜——————————————————————————————————————————————————————————————————————————————————————————
router.post("/LampMirror", (req, res) => {
  console.log("新增灯幻镜");
  // 查询灯幻镜数据库最大的id值
  const sql = "SELECT max(id) FROM slide_projector";
  db.query(sql, (err, result) => {
    if (err) {
      return;
    }
    // 获取最大id的数组
    let ItemID = null;
    // 获取最新的id号
    let ID = null;
    // 循环查询后返回的最大id值
    result.some((item) => {
      // 给其数组赋值
      ItemID = Object.values(item);
    });
    // 判断是否为空是的话最新id为1，反之用最大id+1
    ItemID[0] === null ? (ID = 1) : (ID = ItemID[0] + 1);
    // res.send({
    //   msg: ID,
    //   success: false,
    // });
    // 后端需要赋值的key字段，创建人、创建人id，创建时间，状态，id、是否同意
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "state",
      "id",
      "Agree",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = `${new Date().getFullYear()}-${
      new Date().getMonth() + 1 < 10
        ? `0${new Date().getMonth() + 1}`
        : new Date().getMonth() + 1
    }-${
      new Date().getDate() < 10
        ? `0${new Date().getDate()}`
        : new Date().getDate()
    }`;
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}',0,${ID},0`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO slide_projector(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          data: {
            id: ID,
          },
          msg: "新增成功！",
          success: true,
        });
      }
    });
  });
});
// 新增灯幻镜图片上传——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/LampMirrorStandingPainting", (req, res) => {
  console.log("新增灯幻镜图片上传");
  // 获取请求头传回来的更新列与更新id
  // state等于0幻灯镜、1插画立绘
  let state = req.get("state");
  let id = req.get("id");
  // 判断传回来的更新状态和更新审核单号是否有空
  if (state === "" || state === undefined || id === "" || id === undefined) {
    res.send({
      msg: "上传失败！",
      success: false,
    });
  } else {
    // 查询角色审核库里是否有此数据
    const sql = `SELECT * from slide_projector WHERE id=${id}`;
    db.query(sql, (err, result) => {
      if (err) {
        return;
      }
      if (result.length === 0) {
        // 判断是否找不到或则已经被审批过了
        res.send({
          msg: "未找到相应的审核数据！",
          success: false,
        });
      } else if (result[0].Agree !== 0) {
        res.send({
          msg: "当前审核数据已被审批！",
          success: false,
        });
      } else {
        // 修改文件名的绝对路径
        let url = null;
        // 保存文件的路径
        let URL = null;
        // 判断到底是什么图片提交赋值对应的保存修改的路径
        if (state === "0") {
          url = path.join(`${key.URL}Lamp-Mirror/`);
          URL = "/../public/images/Lamp-Mirror";
        } else if (state === "1") {
          url = path.join(`${key.URL}illustration/`);
          URL = "/../public/images/illustration";
        }
        // 进行保存图片
        let form = formidable({
          multiples: true,
          uploadDir: __dirname + URL, //指定上传到当前项目的那个文件下
          keepExtensions: true, //是否保留后缀名
        });
        //上传完成后的操作
        form.parse(req, (err, fields, files) => {
          if (err) {
            next(err);
            return;
          }
          // 修改文件名，原文件绝对路径，修改后文件绝对路径
          fs.rename(
            url + files.file.newFilename,
            url + id + `.png`,
            (err) => {}
          );
          //响应返回上传文件存放的路径
          // res.json({ url: "/images/" + files.file.newFilename });
          // 修改子段数据库函数
          let sql2 = null;
          let URL2 = null;
          //判断修改那个字段
          if (state === "0") {
            sql2 = `UPDATE slide_projector SET Lamp_Mirror_url='/images/Lamp-Mirror/${id}.png' WHERE id=${id}`;
            URL2 = `/images/Lamp-Mirror/${id}.png`;
          } else if (state === "1") {
            sql2 = `UPDATE slide_projector SET illustration_url='/images/illustration/${id}.png' WHERE id=${id}`;
            URL2 = `/images/illustration/${id}.png`;
          }
          //修改数据库相应数据的图片路径
          db.query(sql2, function (err, rows) {
            if (err) {
              res.send({
                data: "保存数据库失败",
                success: false,
              });
            } else {
              res.send({
                data: URL2,
                success: true,
              });
            }
          });
        });
      }
    });
  }
});
// 新增活动——————————————————————————————————————————————————————————————————————————————————————
router.post("/Activity", (req, res) => {
  console.log("新增活动");
  // 查询灯幻镜数据库最大的id值
  const sql = "SELECT max(id) FROM activity";
  db.query(sql, (err, result) => {
    if (err) {
      return;
    }
    // 获取最大id的数组
    let ItemID = null;
    // 获取最新的id号
    let ID = null;
    // 循环查询后返回的最大id值
    result.some((item) => {
      // 给其数组赋值
      ItemID = Object.values(item);
    });
    // 判断是否为空是的话最新id为1，反之用最大id+1
    ItemID[0] === null ? (ID = 1) : (ID = ItemID[0] + 1);
    // res.send({
    //   msg: ID,
    //   success: false,
    // });
    // 后端需要赋值的key字段，创建人、创建人id，创建时间，状态，id、是否同意
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "state",
      "id",
      "Agree",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}',0,${ID},0`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO activity(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          data: {
            id: ID,
          },
          msg: "新增成功！",
          success: true,
        });
      }
    });
  });
});
// 新增活动图片上传——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/EventStandingPainting", (req, res) => {
  console.log("新增活动图片上传");
  // 获取请求头传回来的更新列与更新id
  // state等于0幻灯镜、1插画立绘
  let state = req.get("state");
  let id = req.get("id");
  // 判断传回来的更新状态和更新审核单号是否有空
  if (state === "" || state === undefined || id === "" || id === undefined) {
    res.send({
      msg: "上传失败！",
      success: false,
    });
  } else {
    // 查询角色审核库里是否有此数据
    const sql = `SELECT * from activity WHERE id=${id}`;
    db.query(sql, (err, result) => {
      if (err) {
        return;
      }
      if (result.length === 0) {
        // 判断是否找不到或则已经被审批过了
        res.send({
          msg: "未找到相应的审核数据！",
          success: false,
        });
      } else if (result[0].Agree !== 0) {
        res.send({
          msg: "当前审核数据已被审批！",
          success: false,
        });
      } else {
        // 修改文件名的绝对路径
        let url = null;
        // 保存文件的路径
        let URL = null;
        // 判断到底是什么图片提交赋值对应的保存修改的路径
        if (state === "0") {
          url = path.join(`${key.URL}ActivityLogo/`);
          URL = "/../public/images/ActivityLogo";
        } else if (state === "1") {
          url = path.join(`${key.URL}Activity/`);
          URL = "/../public/images/Activity";
        }
        // 进行保存图片
        let form = formidable({
          multiples: true,
          uploadDir: __dirname + URL, //指定上传到当前项目的那个文件下
          keepExtensions: true, //是否保留后缀名
        });
        //上传完成后的操作
        form.parse(req, (err, fields, files) => {
          if (err) {
            next(err);
            return;
          }
          // 修改文件名，原文件绝对路径，修改后文件绝对路径
          fs.rename(
            url + files.file.newFilename,
            url + id + `.png`,
            (err) => {}
          );
          //响应返回上传文件存放的路径
          // res.json({ url: "/images/" + files.file.newFilename });
          // 修改子段数据库函数
          let sql2 = null;
          let URL2 = null;
          //判断修改那个字段
          if (state === "0") {
            sql2 = `UPDATE activity SET Activity_icon_url='/images/ActivityLogo/${id}.png' WHERE id=${id}`;
            URL2 = `/images/ActivityLogo/${id}.png`;
          } else if (state === "1") {
            sql2 = `UPDATE activity SET Activity_diagram_url='/images/Activity/${id}.png' WHERE id=${id}`;
            URL2 = `/images/Activity/${id}.png`;
          }
          //修改数据库相应数据的图片路径
          db.query(sql2, function (err, rows) {
            if (err) {
              res.send({
                data: "保存数据库失败",
                success: false,
              });
            } else {
              res.send({
                data: URL2,
                success: true,
              });
            }
          });
        });
      }
    });
  }
});
// 新增道具——————————————————————————————————————————————————————————————————————————————————————
router.post("/Prop", (req, res) => {
  console.log("新增道具");
  // 查询灯幻镜数据库最大的id值
  const sql = "SELECT max(id) FROM props";
  db.query(sql, (err, result) => {
    if (err) {
      return;
    }
    // 获取最大id的数组
    let ItemID = null;
    // 获取最新的id号
    let ID = null;
    // 循环查询后返回的最大id值
    result.some((item) => {
      // 给其数组赋值
      ItemID = Object.values(item);
    });
    // 判断是否为空是的话最新id为1，反之用最大id+1
    ItemID[0] === null ? (ID = 1) : (ID = ItemID[0] + 1);
    // 后端需要赋值的key字段，创建人、创建人id，创建时间，状态，id、是否同意
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "state",
      "id",
      "Agree",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}',0,${ID},0`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO props(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          data: {
            id: ID,
          },
          msg: "新增成功！",
          success: true,
        });
      }
    });
  });
});
// 新增道具图片上传——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/UploadPropMaps", (req, res) => {
  console.log("新增道具图片上传");
  // 获取请求头传回来的更新列与更新id
  // state等于0道具
  let state = req.get("state");
  let id = req.get("id");
  // 判断传回来的更新状态和更新审核单号是否有空
  if (state === "" || state === undefined || id === "" || id === undefined) {
    res.send({
      msg: "上传失败！",
      success: false,
    });
  } else {
    // 查询角色审核库里是否有此数据
    const sql = `SELECT * from props WHERE id=${id}`;
    db.query(sql, (err, result) => {
      if (err) {
        return;
      }
      if (result.length === 0) {
        // 判断是否找不到或则已经被审批过了
        res.send({
          msg: "未找到相应的审核数据！",
          success: false,
        });
      } else if (result[0].Agree !== 0) {
        res.send({
          msg: "当前审核数据已被审批！",
          success: false,
        });
      } else {
        // 修改文件名的绝对路径
        let url = null;
        // 保存文件的路径
        let URL = null;
        // 判断到底是什么图片提交赋值对应的保存修改的路径
        if (state === "0") {
          url = path.join(`${key.URL}material/`);
          URL = "/../public/images/material";
        }
        // 进行保存图片
        let form = formidable({
          multiples: true,
          uploadDir: __dirname + URL, //指定上传到当前项目的那个文件下
          keepExtensions: true, //是否保留后缀名
        });
        //上传完成后的操作
        form.parse(req, (err, fields, files) => {
          if (err) {
            next(err);
            return;
          }
          // 修改文件名，原文件绝对路径，修改后文件绝对路径
          fs.rename(
            url + files.file.newFilename,
            url + id + `.png`,
            (err) => {}
          );
          //响应返回上传文件存放的路径
          // res.json({ url: "/images/" + files.file.newFilename });
          // 修改子段数据库函数
          let sql2 = null;
          let URL2 = null;
          //判断修改那个字段
          if (state === "0") {
            sql2 = `UPDATE props SET url='/images/material/${id}.png' WHERE id=${id}`;
            URL2 = `/images/material/${id}.png`;
          }
          //修改数据库相应数据的图片路径
          db.query(sql2, function (err, rows) {
            if (err) {
              res.send({
                data: "保存数据库失败",
                success: false,
              });
            } else {
              res.send({
                data: URL2,
                success: true,
              });
            }
          });
        });
      }
    });
  }
});
// 新增调伏战——————————————————————————————————————————————————————————————————————————————————————
router.post("/AmbushWarfare", (req, res) => {
  console.log("新增调伏战");
  // 查询灯幻镜数据库最大的id值
  const sql = "SELECT max(id) FROM ambush_warfare";
  db.query(sql, (err, result) => {
    if (err) {
      return;
    }
    // 获取最大id的数组
    let ItemID = null;
    // 获取最新的id号
    let ID = null;
    // 循环查询后返回的最大id值
    result.some((item) => {
      // 给其数组赋值
      ItemID = Object.values(item);
    });
    // 判断是否为空是的话最新id为1，反之用最大id+1
    ItemID[0] === null ? (ID = 1) : (ID = ItemID[0] + 1);
    // res.send({
    //   msg: ID,
    //   success: false,
    // });
    // 后端需要赋值的key字段，创建人、创建人id，创建时间，状态，id、是否同意
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "state",
      "id",
      "Agree",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}',0,${ID},0`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO ambush_warfare(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          data: {
            id: ID,
          },
          msg: "新增成功！",
          success: true,
        });
      }
    });
  });
});
// 新增调伏战图片上传——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/AmbushBattlePicture", (req, res) => {
  console.log("新增调伏战图片上传");
  // 获取请求头传回来的更新列与更新id
  // state等于0调伏战图标、1调伏战立绘
  let state = req.get("state");
  let id = req.get("id");
  // 判断传回来的更新状态和更新审核单号是否有空
  if (state === "" || state === undefined || id === "" || id === undefined) {
    res.send({
      msg: "上传失败！",
      success: false,
    });
  } else {
    // 查询角色审核库里是否有此数据
    const sql = `SELECT * from ambush_warfare WHERE id=${id}`;
    db.query(sql, (err, result) => {
      if (err) {
        return;
      }
      if (result.length === 0) {
        // 判断是否找不到或则已经被审批过了
        res.send({
          msg: "未找到相应的审核数据！",
          success: false,
        });
      } else if (result[0].Agree !== 0) {
        res.send({
          msg: "当前审核数据已被审批！",
          success: false,
        });
      } else {
        // 修改文件名的绝对路径
        let url = null;
        // 保存文件的路径
        let URL = null;
        // 判断到底是什么图片提交赋值对应的保存修改的路径
        if (state === "0") {
          url = path.join(`${key.URL}AmbushWarfareLogo/`);
          URL = "/../public/images/AmbushWarfareLogo";
        } else if (state === "1") {
          url = path.join(`${key.URL}AmbushWarfare/`);
          URL = "/../public/images/AmbushWarfare";
        }
        // 进行保存图片
        let form = formidable({
          multiples: true,
          uploadDir: __dirname + URL, //指定上传到当前项目的那个文件下
          keepExtensions: true, //是否保留后缀名
        });
        //上传完成后的操作
        form.parse(req, (err, fields, files) => {
          if (err) {
            next(err);
            return;
          }
          // 修改文件名，原文件绝对路径，修改后文件绝对路径
          fs.rename(
            url + files.file.newFilename,
            url + id + `.png`,
            (err) => {}
          );
          //响应返回上传文件存放的路径
          // res.json({ url: "/images/" + files.file.newFilename });
          // 修改子段数据库函数
          let sql2 = null;
          let URL2 = null;
          //判断修改那个字段
          if (state === "0") {
            sql2 = `UPDATE ambush_warfare SET Activity_icon_url='/images/AmbushWarfareLogo/${id}.png' WHERE id=${id}`;
            URL2 = `/images/AmbushWarfareLogo/${id}.png`;
          } else if (state === "1") {
            sql2 = `UPDATE ambush_warfare SET Activity_diagram_url='/images/AmbushWarfare/${id}.png' WHERE id=${id}`;
            URL2 = `/images/AmbushWarfare/${id}.png`;
          }
          //修改数据库相应数据的图片路径
          db.query(sql2, function (err, rows) {
            if (err) {
              res.send({
                data: "保存数据库失败",
                success: false,
              });
            } else {
              res.send({
                data: URL2,
                success: true,
              });
            }
          });
        });
      }
    });
  }
});
// 新增卡池——————————————————————————————————————————————————————————————————————————————————————
router.post("/CardPools", (req, res) => {
  console.log("新增卡池");
  // 查询灯幻镜数据库最大的id值
  const sql = "SELECT max(id) FROM card_pools";
  db.query(sql, (err, result) => {
    if (err) {
      return;
    }
    // 获取最大id的数组
    let ItemID = null;
    // 获取最新的id号
    let ID = null;
    // 循环查询后返回的最大id值
    result.some((item) => {
      // 给其数组赋值
      ItemID = Object.values(item);
    });
    // 判断是否为空是的话最新id为1，反之用最大id+1
    ItemID[0] === null ? (ID = 1) : (ID = ItemID[0] + 1);
    // res.send({
    //   msg: ID,
    //   success: false,
    // });
    // 后端需要赋值的key字段，创建人、创建人id，创建时间，状态，id、是否同意
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "state",
      "id",
      "Agree",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}',0,${ID},0`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO card_pools(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          data: {
            id: ID,
          },
          msg: "新增成功！",
          success: true,
        });
      }
    });
  });
});
// 新增卡池图片上传——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/CardPoolsImage", (req, res) => {
  console.log("新增卡池图片上传");
  // 获取请求头传回来的更新列与更新id
  // state等于1卡池图
  let state = req.get("state");
  let id = req.get("id");
  // 判断传回来的更新状态和更新审核单号是否有空
  if (state === "" || state === undefined || id === "" || id === undefined) {
    res.send({
      msg: "上传失败！",
      success: false,
    });
  } else {
    // 查询角色审核库里是否有此数据
    const sql = `SELECT * from card_pools WHERE id=${id}`;
    db.query(sql, (err, result) => {
      if (err) {
        return;
      }
      if (result.length === 0) {
        // 判断是否找不到或则已经被审批过了
        res.send({
          msg: "未找到相应的审核数据！",
          success: false,
        });
      } else if (result[0].Agree !== 0) {
        res.send({
          msg: "当前审核数据已被审批！",
          success: false,
        });
      } else {
        // 修改文件名的绝对路径
        let url = null;
        // 保存文件的路径
        let URL = null;
        // 判断到底是什么图片提交赋值对应的保存修改的路径
        if (state === "1") {
          url = path.join(`${key.URL}Card-pools/`);
          URL = "/../public/images/Card-pools";
        }
        // 进行保存图片
        let form = formidable({
          multiples: true,
          uploadDir: __dirname + URL, //指定上传到当前项目的那个文件下
          keepExtensions: true, //是否保留后缀名
        });
        //上传完成后的操作
        form.parse(req, (err, fields, files) => {
          if (err) {
            next(err);
            return;
          }
          // 修改文件名，原文件绝对路径，修改后文件绝对路径
          fs.rename(
            url + files.file.newFilename,
            url + id + `.png`,
            (err) => {}
          );
          //响应返回上传文件存放的路径
          // res.json({ url: "/images/" + files.file.newFilename });
          // 修改子段数据库函数
          let sql2 = null;
          let URL2 = null;
          //判断修改那个字段
          if (state === "1") {
            sql2 = `UPDATE card_pools SET Card_pools_url='/images/Card-pools/${id}.png' WHERE id=${id}`;
            URL2 = `/images/Card-pools/${id}.png`;
          }
          //修改数据库相应数据的图片路径
          db.query(sql2, function (err, rows) {
            if (err) {
              res.send({
                data: "保存数据库失败",
                success: false,
              });
            } else {
              res.send({
                data: URL2,
                success: true,
              });
            }
          });
        });
      }
    });
  }
});
// 新增角色灯幻镜矩阵接口——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/MatrixNew", (req, res) => {
  console.log("新增角色灯幻镜矩阵");
  if (
    req.body.name &&
    req.body.level &&
    req.body.levelName &&
    req.body.classify
  ) {
    // 查询灯幻镜数据库最大的id值
    // 后端需要赋值的创建人、创建人id，创建时间，可否操作
    let Keys = ["Created_By", "Created_ID", "Created_Data", "state"];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}',0`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO enum(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          msg: "新增成功！",
          success: true,
        });
      }
    });
  } else {
    res.send({
      msg: "未知错误！",
      success: false,
    });
  }
});
// 新增道具矩阵接口——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/PropMatrix", (req, res) => {
  console.log("新增道具矩阵");
  if (req.body.name) {
    // 查询灯幻镜数据库最大的id值
    // 后端需要赋值的创建人、创建人id，创建时间，可否操作
    let Keys = ["Created_By", "Created_ID", "Created_Data"];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}'`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO props_matrix(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          msg: "新增成功！",
          success: true,
        });
      }
    });
  } else {
    res.send({
      msg: "未知错误！",
      success: false,
    });
  }
});
// 新增模拟抽卡——————————————————————————————————————————————————————————————————————————————————————
router.post("/SimulatedGacha", (req, res) => {
  console.log("新增模拟抽卡");

  // 后端需要赋值的key字段，创建人、创建人id，创建时间
  let Keys = ["Created_By", "Created_ID", "Created_Data"];
  // 获取前端key字段并与后端新加字段合并转化成字符串
  let Key = Object.keys(req.body).concat(Keys).join(",");
  // 数据库赋值数据字段的字段
  let Values = "";
  // 循环前端传回来的数据valise
  Object.values(req.body).some((item) => {
    // 如果为空值则赋值null
    if (item === "") {
      Values = Values + "null,";
    } else if (typeof item === "object") {
      // 如果是数组则转化完后赋值
      Values = Values + "'" + JSON.stringify(item) + "'" + ",";
    } else {
      // 其余照常赋值
      Values = Values + "'" + item + "'" + ",";
    }
  });
  // 获取当前时间的拼接
  let DateItem = dayjs().format("YYYY-MM-DD");
  // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
  let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}'`;
  // 将前后端的合并
  Values = Values + Valuess;
  // 请求数据库
  const sql2 = `INSERT INTO simulated_gacha(${Key}) VALUES(${Values}) `;
  db.query(sql2, function (err, rows) {
    if (err) {
      res.send({
        msg: "新增失败！",
        success: false,
      });
    } else {
      res.send({
        msg: "新增成功！",
        success: true,
      });
    }
  });
});
// 新增遗迹内容——————————————————————————————————————————————————————————————————————————————————————
router.post("/RelicsContentAdded", (req, res) => {
  console.log("新增遗迹内容");

  // 后端需要赋值的key字段，创建人、创建人id，创建时间
  let Keys = ["Created_By", "Created_ID", "Created_Data"];
  // 获取前端key字段并与后端新加字段合并转化成字符串
  let Key = Object.keys(req.body).concat(Keys).join(",");
  // 数据库赋值数据字段的字段
  let Values = "";
  // 循环前端传回来的数据valise
  Object.values(req.body).some((item) => {
    // 如果为空值则赋值null
    if (item === "") {
      Values = Values + "null,";
    } else if (typeof item === "object") {
      // 如果是数组则转化完后赋值
      Values = Values + "'" + JSON.stringify(item) + "'" + ",";
    } else {
      // 其余照常赋值
      Values = Values + "'" + item + "'" + ",";
    }
  });
  // 获取当前时间的拼接
  let DateItem = dayjs().format("YYYY-MM-DD");
  // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
  let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}'`;
  // 将前后端的合并
  Values = Values + Valuess;
  // 请求数据库
  const sql2 = `INSERT INTO relic(${Key}) VALUES(${Values}) `;
  db.query(sql2, function (err, rows) {
    if (err) {
      res.send({
        msg: "新增失败！",
        success: false,
      });
    } else {
      res.send({
        msg: "新增成功！",
        success: true,
      });
    }
  });
});
// 新增遗迹一级目录接口——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/RuinsLevelOne", (req, res) => {
  console.log(" 新增遗迹一级目录");
  if (
    req.body.name &&
    req.body.levelName &&
    req.body.logo &&
    req.body.background
  ) {
    // 查询灯幻镜数据库最大的id值
    // 后端需要赋值的创建人、创建人id，创建时间，可否操作
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "state",
      "level",
      "classify",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}','0',1,'遗迹'`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO enum(${Key}) VALUES(${Values}) `;
    console.log(sql2);
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          msg: "新增成功！",
          success: true,
        });
      }
    });
  } else {
    res.send({
      msg: "未知错误！",
      success: false,
    });
  }
});
// 新增新闻公告——————————————————————————————————————————————————————————————————————————————————————
router.post("/NewPressReleases", (req, res) => {
  console.log("新增新闻公告");

  // 后端需要赋值的key字段，创建人、创建人id，创建时间,公告日期
  let Keys = ["Created_By", "Created_ID", "Created_Data", "noticeDate"];
  // 获取前端key字段并与后端新加字段合并转化成字符串
  let Key = Object.keys(req.body).concat(Keys).join(",");
  // 数据库赋值数据字段的字段
  let Values = "";
  // 循环前端传回来的数据valise
  Object.values(req.body).some((item) => {
    // 如果为空值则赋值null
    if (item === "") {
      Values = Values + "null,";
    } else if (typeof item === "object") {
      // 如果是数组则转化完后赋值
      Values = Values + "'" + JSON.stringify(item) + "'" + ",";
    } else {
      // 其余照常赋值
      Values = Values + "'" + item + "'" + ",";
    }
  });
  // 获取当前时间的拼接
  let DateItem = dayjs().format("YYYY-MM-DD");
  // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
  let Valuess = `'${req.auth.name}',${
    req.auth.id
  },'${DateItem}','${dayjs().format("YYYY-MM-DD HH:mm:ss")}'`;
  // 将前后端的合并
  Values = Values + Valuess;
  // 请求数据库
  const sql2 = `INSERT INTO press_releases(${Key}) VALUES(${Values}) `;
  console.log(sql2);
  db.query(sql2, function (err, rows) {
    if (err) {
      res.send({
        msg: "新增失败！",
        success: false,
      });
    } else {
      res.send({
        msg: "新增成功！",
        success: true,
      });
    }
  });
});
// 新增词条解析——————————————————————————————————————————————————————————————————————————————————————
router.post("/WordAnalysis", (req, res) => {
  console.log("新增词条解析");

  // 后端需要赋值的key字段，创建人、创建人id，创建时间,公告日期
  let Keys = ["Created_By", "Created_ID", "Created_Data"];
  // 获取前端key字段并与后端新加字段合并转化成字符串
  let Key = Object.keys(req.body).concat(Keys).join(",");
  // 数据库赋值数据字段的字段
  let Values = "";
  // 循环前端传回来的数据valise
  Object.values(req.body).some((item) => {
    // 如果为空值则赋值null
    if (item === "") {
      Values = Values + "null,";
    } else if (typeof item === "object") {
      // 如果是数组则转化完后赋值
      Values = Values + "'" + JSON.stringify(item) + "'" + ",";
    } else {
      // 其余照常赋值
      Values = Values + "'" + item + "'" + ",";
    }
  });
  // 获取当前时间的拼接
  let DateItem = dayjs().format("YYYY-MM-DD");
  // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
  let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}'`;
  // 将前后端的合并
  Values = Values + Valuess;
  // 请求数据库
  const sql2 = `INSERT INTO word_analysis(${Key}) VALUES(${Values}) `;
  db.query(sql2, function (err, rows) {
    if (err) {
      res.send({
        msg: "新增失败！",
        success: false,
      });
    } else {
      res.send({
        msg: "新增成功！",
        success: true,
      });
    }
  });
});
// 新增用户——————————————————————————————————————————————————————————————————————————————————————
router.post("/User", (req, res) => {
  console.log("新增用户");
  let sql = `SELECT * FROM user WHERE id LIKE '%${dayjs().format(
    "YYYYMMDD"
  )}%' `;
  // 查这个月的新增数量
  db.query(sql, function (err, result) {
    if (err) {
      return;
    }
    // 后端需要赋值的key字段，创建人、创建人id,id,权限码,创建时间
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "id",
      "Permissions",
      "data",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
    let Valuess = `'${req.auth.name}',${
      req.auth.id
    },'${DateItem}','${dayjs().format("YYYYMMDD")}${
      result.length + 1
    }','increase-${
      Math.floor(Math.random() * (10000 - 1000 + 1)) + 1000
    }-root','${DateItem}'`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO user(${Key}) VALUES(${Values}) `;
    console.log(sql2);
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          msg: "新增成功！",
          success: true,
        });
      }
    });
  });
});
// 新增神代盘——————————————————————————————————————————————————————————————————————————————————————
router.post("/GodGeneration", (req, res) => {
  console.log("新增神代盘");
  // 后端需要赋值的key字段，创建人、创建人id，创建时间,公告日期
  let Keys = ["Created_By", "Created_ID", "Created_Data"];
  // 获取前端key字段并与后端新加字段合并转化成字符串
  let Key = Object.keys(req.body).concat(Keys).join(",");
  // 数据库赋值数据字段的字段
  let Values = "";
  // 循环前端传回来的数据valise
  Object.values(req.body).some((item) => {
    // 如果为空值则赋值null
    if (item === "") {
      Values = Values + "null,";
    } else if (typeof item === "object") {
      // 如果是数组则转化完后赋值
      Values = Values + "'" + JSON.stringify(item) + "'" + ",";
    } else {
      // 其余照常赋值
      Values = Values + "'" + item + "'" + ",";
    }
  });
  // 获取当前时间的拼接
  let DateItem = dayjs().format("YYYY-MM-DD");
  // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
  let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}'`;
  // 将前后端的合并
  Values = Values + Valuess;
  // 请求数据库
  const sql2 = `INSERT INTO god_generation(${Key}) VALUES(${Values}) `;
  console.log(sql2);
  db.query(sql2, function (err, rows) {
    if (err) {
      res.send({
        msg: "新增失败！",
        success: false,
      });
    } else {
      res.send({
        msg: "新增成功！",
        success: true,
      });
    }
  });
});
// 新增称号系列内容——————————————————————————————————————————————————————————————————————————————————————
router.post("/TitleSeries", (req, res) => {
  console.log("新增称号系列");

  // 后端需要赋值的key字段，创建人、创建人id，创建时间,层级,类型，是否可操作,层级对应名称
  let Keys = [
    "Created_By",
    "Created_ID",
    "Created_Data",
    "level",
    "classify",
    "state",
    "levelName",
  ];
  // 获取前端key字段并与后端新加字段合并转化成字符串
  let Key = Object.keys(req.body).concat(Keys).join(",");
  // 数据库赋值数据字段的字段
  let Values = "";
  // 循环前端传回来的数据valise
  Object.values(req.body).some((item) => {
    // 如果为空值则赋值null
    if (item === "") {
      Values = Values + "null,";
    } else if (typeof item === "object") {
      // 如果是数组则转化完后赋值
      Values = Values + "'" + JSON.stringify(item) + "'" + ",";
    } else {
      // 其余照常赋值
      Values = Values + "'" + item + "'" + ",";
    }
  });
  // 获取当前时间的拼接
  let DateItem = dayjs().format("YYYY-MM-DD");
  // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、,层级,类型，是否可操作
  let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}','1','称号系列','0','无'`;
  // 将前后端的合并
  Values = Values + Valuess;
  // 请求数据库
  const sql2 = `INSERT INTO enum(${Key}) VALUES(${Values}) `;
  console.log(sql2);
  db.query(sql2, function (err, rows) {
    if (err) {
      res.send({
        msg: "新增失败！",
        success: false,
      });
    } else {
      res.send({
        msg: "新增成功！",
        success: true,
      });
    }
  });
});
// 新增称号一览——————————————————————————————————————————————————————————————————————————————————————
router.post("/TitleEdit", (req, res) => {
  console.log("新增称号一览");

  // 后端需要赋值的key字段，创建人、创建人id，创建时间,公告日期
  let Keys = ["Created_By", "Created_ID", "Created_Data"];
  // 获取前端key字段并与后端新加字段合并转化成字符串
  let Key = Object.keys(req.body).concat(Keys).join(",");
  // 数据库赋值数据字段的字段
  let Values = "";
  // 循环前端传回来的数据valise
  Object.values(req.body).some((item) => {
    // 如果为空值则赋值null
    if (item === "") {
      Values = Values + "null,";
    } else if (typeof item === "object") {
      // 如果是数组则转化完后赋值
      Values = Values + "'" + JSON.stringify(item) + "'" + ",";
    } else {
      // 其余照常赋值
      Values = Values + "'" + item + "'" + ",";
    }
  });
  // 获取当前时间的拼接
  let DateItem = dayjs().format("YYYY-MM-DD");
  // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
  let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}'`;
  // 将前后端的合并
  Values = Values + Valuess;
  // 请求数据库
  const sql2 = `INSERT INTO title_edit(${Key}) VALUES(${Values}) `;
  console.log(sql2);
  db.query(sql2, function (err, rows) {
    if (err) {
      res.send({
        msg: "新增失败！",
        success: false,
      });
    } else {
      res.send({
        msg: "新增成功！",
        success: true,
      });
    }
  });
});
// 新增封灭战——————————————————————————————————————————————————————————————————————————————————————
router.post("/WarOfAnnihilation", (req, res) => {
  console.log("新增封灭战");
  // 查询灯幻镜数据库最大的id值
  const sql = "SELECT max(id) FROM war_of_annihilation";
  db.query(sql, (err, result) => {
    if (err) {
      return;
    }
    // 获取最大id的数组
    let ItemID = null;
    // 获取最新的id号
    let ID = null;
    // 循环查询后返回的最大id值
    result.some((item) => {
      // 给其数组赋值
      ItemID = Object.values(item);
    });
    // 判断是否为空是的话最新id为1，反之用最大id+1
    ItemID[0] === null ? (ID = 1) : (ID = ItemID[0] + 1);
    // res.send({
    //   msg: ID,
    //   success: false,
    // });
    // 后端需要赋值的key字段，创建人、创建人id，创建时间，状态，id、是否同意
    let Keys = [
      "Created_By",
      "Created_ID",
      "Created_Data",
      "state",
      "id",
      "Agree",
    ];
    // 获取前端key字段并与后端新加字段合并转化成字符串
    let Key = Object.keys(req.body).concat(Keys).join(",");
    // 数据库赋值数据字段的字段
    let Values = "";
    // 循环前端传回来的数据valise
    Object.values(req.body).some((item) => {
      // 如果为空值则赋值null
      if (item === "") {
        Values = Values + "null,";
      } else if (typeof item === "object") {
        // 如果是数组则转化完后赋值
        Values = Values + "'" + JSON.stringify(item) + "'" + ",";
      } else {
        // 其余照常赋值
        Values = Values + "'" + item + "'" + ",";
      }
    });
    // 获取当前时间的拼接
    let DateItem = dayjs().format("YYYY-MM-DD");
    // 将后端要赋值的字段进行拼接，创建人、创建人id、创建时间、状态，id、是否同意
    let Valuess = `'${req.auth.name}',${req.auth.id},'${DateItem}',0,${ID},0`;
    // 将前后端的合并
    Values = Values + Valuess;
    // 请求数据库
    const sql2 = `INSERT INTO war_of_annihilation(${Key}) VALUES(${Values}) `;
    db.query(sql2, function (err, rows) {
      if (err) {
        res.send({
          msg: "新增失败！",
          success: false,
        });
      } else {
        res.send({
          data: {
            id: ID,
          },
          msg: "新增成功！",
          success: true,
        });
      }
    });
  });
});
// 新增封灭战图片上传——————————————————————————————————————————————————————————————————————————————————————————————————————
router.post("/WarOfAnnihilationPicture", (req, res) => {
  console.log("新增调封灭战图片上传");
  // 获取请求头传回来的更新列与更新id
  // state等于0调伏战图标、1调伏战立绘
  let state = req.get("state");
  let id = req.get("id");
  // 判断传回来的更新状态和更新审核单号是否有空
  if (state === "" || state === undefined || id === "" || id === undefined) {
    res.send({
      msg: "上传失败！",
      success: false,
    });
  } else {
    // 查询角色审核库里是否有此数据
    const sql = `SELECT * from war_of_annihilation WHERE id=${id}`;
    db.query(sql, (err, result) => {
      if (err) {
        return;
      }
      if (result.length === 0) {
        // 判断是否找不到或则已经被审批过了
        res.send({
          msg: "未找到相应的审核数据！",
          success: false,
        });
      } else if (result[0].Agree !== 0) {
        res.send({
          msg: "当前审核数据已被审批！",
          success: false,
        });
      } else {
        // 修改文件名的绝对路径
        let url = null;
        // 保存文件的路径
        let URL = null;
        // 判断到底是什么图片提交赋值对应的保存修改的路径
        if (state === "0") {
          url = path.join(`${key.URL}WarOfAnnihilationLogo/`);
          URL = "/../public/images/WarOfAnnihilationLogo";
        } else if (state === "1") {
          url = path.join(`${key.URL}WarOfAnnihilation/`);
          URL = "/../public/images/WarOfAnnihilation";
        }
        // 进行保存图片
        let form = formidable({
          multiples: true,
          uploadDir: __dirname + URL, //指定上传到当前项目的那个文件下
          keepExtensions: true, //是否保留后缀名
        });
        //上传完成后的操作
        form.parse(req, (err, fields, files) => {
          if (err) {
            next(err);
            return;
          }
          // 修改文件名，原文件绝对路径，修改后文件绝对路径
          fs.rename(
            url + files.file.newFilename,
            url + id + `.png`,
            (err) => {}
          );
          //响应返回上传文件存放的路径
          // res.json({ url: "/images/" + files.file.newFilename });
          // 修改子段数据库函数
          let sql2 = null;
          let URL2 = null;
          //判断修改那个字段
          if (state === "0") {
            sql2 = `UPDATE war_of_annihilation SET Activity_icon_url='/images/WarOfAnnihilationLogo/${id}.png' WHERE id=${id}`;
            URL2 = `/images/WarOfAnnihilationLogo/${id}.png`;
          } else if (state === "1") {
            sql2 = `UPDATE war_of_annihilation SET Activity_diagram_url='/images/WarOfAnnihilation/${id}.png' WHERE id=${id}`;
            URL2 = `/images/WarOfAnnihilation/${id}.png`;
          }
          //修改数据库相应数据的图片路径
          db.query(sql2, function (err, rows) {
            if (err) {
              res.send({
                data: "保存数据库失败",
                success: false,
              });
            } else {
              res.send({
                data: URL2,
                success: true,
              });
            }
          });
        });
      }
    });
  }
});
module.exports = router;
